package mx.ipn.negocios.telefonista;

import mx.ipn.negocios.CodigosDeError;
import mx.ipn.negocios.ConexionConPersistencia;
import mx.ipn.to.*;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.util.*;

public class BitacoraServiciosBO {
	private static ArrayList<Short> revisiones = new ArrayList<Short>();
	private static ArrayList<BitacoraServicioTO> bitacora;
	private static short revision = 0;
	
	// solo los cambios
	public static synchronized PeticionBitacoraServiciosPorRevisionTO obtenerRevision(short revisionDelCliente){
		// Obtiene el nombre de la clase sin los paquetes
		String nombre = BitacoraServiciosBO.class.getName();
		int primerCaracter;
		
		primerCaracter = nombre.lastIndexOf ('.') + 1;
		if ( primerCaracter > 0 ) {
			nombre = nombre.substring ( primerCaracter );
		}

		// Crea el archivo e inicia el log
		PrintStream printStream;

		try{
			File dir = new File(mx.ipn.Constantes.DIRECTORIO_DE_LOGS);
			if(!dir.exists())
				dir.mkdirs();
			
			File file = new File(dir,"saist" + nombre + revision + ".log");
			printStream = new PrintStream(new BufferedOutputStream(new FileOutputStream(file)), true);
			System.setErr(printStream);
			System.setOut(printStream);
			
			System.out.println("EL log ha nacido: "+ new java.util.Date());
		}catch(IOException e){
			System.err.println ("El archivo se niega cobardemente a ser escrito...");
		}
		/****************************/
			/*
		for(int i=0; i<revisiones.size(); i++)
			System.out.println("revisiones key: " + (i) + "valor: " + revisiones.get(i));
		for(int i=0; i<bitacora.size(); i ++)
			System.out.println("bitacora: " + i);
		*/

		PeticionBitacoraServiciosPorRevisionTO to = new PeticionBitacoraServiciosPorRevisionTO();
		
		System.out.println("antes de if");
		// si la revision actual del cliente es igual a la revision actual del servidor
		if(revisionDelCliente == revision){
			System.out.println("if");
			// regresar la misma revision (solo el numero)
			to.setRevision(revision);  
			return to;
		}
		
		//si no, regresar solo los cambios (las revisiones consecuentes)
		else{
			System.out.println("else");
			
			//se crea de acorde al tamaño necesario, solo contendra las revisiones que carece el cliente
			BitacoraServicioTO[] toBS = new BitacoraServicioTO[revision-revisionDelCliente];
			short[] renglones = new short[revision-revisionDelCliente];
			System.out.println("Creo datos");
		
			//se llenan las revisiones
			for( int i = revisionDelCliente, j=0; i < revision; i++){
				System.out.println("for i: " + i + " j: " + j);
				
				 // que renglon se modifico en la revision siguiente a la del cliente
				  
				System.out.println("revisiones[i+1]: " + revisiones.get(i));

					renglones[j] = revisiones.get(i);
					System.out.println("renglones[j]: " + renglones[j]);
				  
				 // los datos de ese renglon
				  toBS[j] = bitacora.get(renglones[j]);
					System.out.println("id bitacora: " + toBS[j].getIdOperacion());

				  j++;
			}

			System.out.println("paso for");
			
			// numero de revision
			to.setRevision(revision);
			// renglones afectados
			to.setRenglon(renglones);
			// data de renglones
			to.setBitacora(toBS);
			
			return to;
		}
	}
	
	public static BitacoraServicioTO obtenerBitacoraPorFechaTelefonista(PeticionBitacoraServicioTO to ){
		BitacoraServicioTO resp = (BitacoraServicioTO) ConexionConPersistencia.invocaServicio("obtenerBitacoraServiciosPorFechaTelefonista", to, BitacoraServicioTO.class);
		
		return resp;
	}
	
	// Pedir toda la bitacora
	public static PeticionBitacoraServiciosPorRevisionTO obtenerBitacoraPorDia(java.util.Date dia){
		PeticionBitacoraServiciosPorRevisionTO to = new PeticionBitacoraServiciosPorRevisionTO();
		BitacoraServicioTO[] resp;
		
		// la primera vez que se pide se pide a la bd
		if(revision==0){
			resp = (BitacoraServicioTO[]) ConexionConPersistencia.invocaServicio("obtenerBitacoraServiciosPorDia", dia, BitacoraServicioTO[].class);

			if(resp!=null)
			if(resp.length>0){
				bitacora = new ArrayList<BitacoraServicioTO>( Arrays.asList( resp ) );
				revision=1;
				revisiones.add((short)(bitacora.size()-1));
			}
		}
		
		// despues de la local de negocios
		else
			resp = (BitacoraServicioTO[]) bitacora
			.toArray(new BitacoraServicioTO[bitacora.size()]);
			
		to.setRevision(revision);
		to.setBitacora(resp);

		return to;

	}
	
	public static synchronized TransferObject actualizarBitacoraServicios(PeticionBitacoraServiciosPorRevisionTO to){

		ConexionConPersistencia.invocaServicio("actualizarBitacoraServicios", to.getBitacora()[0], Short.class);
		
		revision++;
		
		// buscar la bitacora que se agrego
		BitacoraServicioTO b = (BitacoraServicioTO) ConexionConPersistencia.invocaServicio("buscarBitacoraPorId", to.getBitacora()[0].getIdOperacion(), BitacoraServicioTO.class);

		// se agrega la revision siguiente, al siguiente renglon
		revisiones.add(to.getRenglon()[0]);
		
		bitacora.remove(to.getRenglon()[0]);
		bitacora.add(to.getRenglon()[0], b);
		
		return null;
	}
	
	public static synchronized TransferObject agregarServicio(BitacoraServicioTO bitacoraTO){
		TransferObject to = new TransferObject();
			
		int idBitacora = (Integer) ConexionConPersistencia.invocaServicio("agregarServicio", bitacoraTO, Integer.class);
	
		if(idBitacora>0 )
		{
			to.setTipoError(TransferObject.INFO);
			to.setError(CodigosDeError.error.get(10001));
		}
		else
		{
			to.setTipoError(TransferObject.ERROR);
			to.setError(CodigosDeError.error.get(10000));
		}

		revision++;
			
		// buscar la bitacora que se agrego
		BitacoraServicioTO b = (BitacoraServicioTO) ConexionConPersistencia.invocaServicio("buscarBitacoraPorId", idBitacora, BitacoraServicioTO.class);
		if(bitacora==null){
			System.out.println("bitacora era nulo");
			bitacora = new ArrayList<BitacoraServicioTO>();
		}

		// se agrega la revision siguiente, al siguiente renglon
		revisiones.add((short)bitacora.size());
		
		bitacora.add(b);
		
		return to;
	}
}
